import domainsConfig from '~/public/config/domains.json'

// 域名配置类型定义
export interface ThemeConfig {
  name: string
  description: string
  primaryColor: string
  secondaryColor: string
  logo: string
  favicon: string
  pla_icon: string
  dataLayer: string,
  iconBaseUrl: string
}

export interface AnalyticsConfig {
  GAId: string
  posthogId: string
  posthogHostname: string
  tiktokId: string
  mintegralId: string
  bigoId: string
  facebookPixelId: string
  gamId: string
  adsClientId: string
  email: string
  adsText: string
}

export interface GamConfig {
  enable: boolean
  interstitial: string
  topAnchor: string
  bottomAnchor: string,
  rewarded: string,
  mainDisplay1: string
  detailDisplay1: string
  detailDisplay2: string
  favoritesDisplay1: string
  searchDisplay1: string
  [key: string]: string | boolean
}

export interface AdsConfig {
  enable: boolean
  homeDisplay: string
  detailDisplay: string
  [key: string]: string | boolean
}

export interface DomainConfig {
  name: string
  description: string
  theme: ThemeConfig
  analytics: AnalyticsConfig
  gamConfig: GamConfig
  adsConfig: AdsConfig
}

export interface DomainConfigData {
  domains: Record<string, DomainConfig>
  default: DomainConfig
}

// 缓存配置数据
let configCache: DomainConfigData | null = null

/**
 * 获取域名配置数据
 * @returns DomainConfigData
 */
export function getDomainConfigData(): DomainConfigData {
  if (configCache) {
    return configCache
  }
  configCache = domainsConfig as unknown as DomainConfigData
  return configCache
}

/**
 * 获取所有域名列表
 * @returns string[]
 */
export function getAllDomains(): string[] {
  try {
    const configData = getDomainConfigData()
    return Object.keys(configData.domains)
  } catch (error) {
    console.error('Error getting all domains:', error)
    return []
  }
}

/**
 * 获取指定域名的完整配置
 * @param hostname 可选的 hostname 参数，如果不提供则使用默认值
 * @returns DomainConfig | null
 */
export function getDomainConfig(hostname?: string): DomainConfig | null {
  // 如果没有提供 hostname，返回默认配置
  if (!hostname) {
    try {
      const configData = getDomainConfigData()
      return configData.default || null
    } catch (error) {
      console.error('Error getting default domain config:', error)
      return null
    }
  }
  
  try {
    const configData = getDomainConfigData()
    // 优先匹配当前域名，如果没有，再次匹配主域名，如果都没有，返回default
    if (configData.domains[hostname]) {
      return configData.domains[hostname]
    }
    const domainParts = hostname.split('.')
    const mainDomain = domainParts.slice(domainParts.length - 2).join('.')
    if (configData.domains[mainDomain]) {
      return configData.domains[mainDomain]
    }
    return configData.default || null
  } catch (error) {
    console.error(`Error getting domain config for ${hostname}:`, error)
    return null
  }
}

/**
 * 获取指定域名的主题配置
 * @param hostname 可选的 hostname 参数
 * @returns ThemeConfig | null
 */
export function getThemeConfig(hostname?: string): ThemeConfig | null {
  try {
    const domainConfig = getDomainConfig(hostname)
    return domainConfig?.theme || null
  } catch (error) {
    console.error('Error getting theme config:', error)
    return null
  }
}

/**
 * 获取指定域名的分析配置
 * @param hostname 可选的 hostname 参数
 * @returns AnalyticsConfig | null
 */
export function getAnalyticsConfig(domain: string): AnalyticsConfig | null {
  try {
    const domainConfig = getDomainConfig(domain)
    return domainConfig?.analytics || null
  } catch (error) {
    console.error('Error getting analytics config:', error)
    return null
  }
}

export function getEmail(domain: string): string | null {
  try {
    const domainConfig = getDomainConfig(domain)
    return domainConfig?.analytics?.email || null
  } catch (error) {
    console.error('Error getting email:', error)
    return null
  }
}

/**
 * 获取指定域名的adsText
 * @param domain 可选的 domain 参数
 * @returns string | null
 */
export function getAdsText(domain: string): string | null {
  try {
    const domainConfig = getDomainConfig(domain)
    return domainConfig?.analytics?.adsText || null
  } catch (error) {
    console.error('Error getting ads text:', error)
    return null
  }
}

/**
 * 获取指定域名的GAM配置
 * @param hostname 可选的 hostname 参数
 * @returns GamConfig | null
 */
export function getGamConfig(domain: string): GamConfig | null {
  try {
    const domainConfig = getDomainConfig(domain)
    return domainConfig?.gamConfig || null
  } catch (error) {
    console.error('Error getting gam config:', error)
    return null
  }
}

/**
 * 获取指定域名的广告配置
 * @param hostname 可选的 hostname 参数
 * @returns AdsConfig | null
 */
export function getAdsConfig(domain: string): AdsConfig | null {
  try {
    const domainConfig = getDomainConfig(domain)
    return domainConfig?.adsConfig || null
  } catch (error) {
    console.error('Error getting ads config:', error)
    return null
  }
}

/**
 * 获取指定域名的gamEnable
 * @param domain 可选的 domain 参数
 * @returns boolean | null
 */
export function getGamEnable(domain: string): boolean | null {
  const gamConfig = getGamConfig(domain)
  return gamConfig?.enable || null
}

/**
 * 获取指定域名的adsEnable
 * @param domain 可选的 domain 参数
 * @returns boolean | null
 */
export function getAdsEnable(domain: string): boolean | null {
  const adsConfig = getAdsConfig(domain)
  return adsConfig?.enable || null
}

/**
 * 获取当前域名
 * @returns string
 */

// 获取指定域名的gam的指定广告位，并将gamId拼接在一起
export function getGamAdSlot(slotType: string, domain: string): { gamPath: string | null; slot: string } {
  const gamConfig = getGamConfig(domain)
  const slotConfig = gamConfig?.[slotType]
  
  // 类型检查：确保slotConfig是对象而不是字符串
  const config = {
    gamId: getAnalyticsConfig(domain)?.gamId || '',
    slot: (slotConfig && typeof slotConfig === 'string') ? slotConfig : '',
  }
  return {
    gamPath: config.slot ? `${config.gamId}${config.slot}` : null,
    slot: config.slot
  }
}

// 获取gam自动广告位，并将gamId拼接在一起
export function getGamAutoAdSlot(autoType: string, domain: string): string | null {
  const gamId = getAnalyticsConfig(domain)?.gamId || ''
  
  const gamConfig = getGamConfig(domain)
  const slotConfig = (gamConfig && typeof gamConfig[autoType] === 'string') ? gamConfig?.[autoType] : null
  return slotConfig ? `${gamId}${slotConfig}` : null
}

// 获取指定域名的ads的指定广告位
export function getAdsAdSlot(slotType: string, domain: string): string | null {
  const config = getAdsConfig(domain)
  const value = config?.[slotType]
  return typeof value === 'string' ? value : null
}

// 获取指定域名的adsClientId
export function getadsClientId(domain: string): string | null {
  const config = getAnalyticsConfig(domain)
  return config?.adsClientId || null
}

// 获取指定域名的dataLayer
export function getDataLayer(domain: string): string {
  const config = getThemeConfig(domain)
  return config?.dataLayer || 'ai'
}

/**
 * 清除配置缓存
 */
export function clearConfigCache(): void {
  configCache = null
} 

/**
 * 统一替换图片资源域名
 * @param data 需要处理的数据对象或数组
 * @param hostname 可选的 hostname 参数，用于获取对应的域名配置
 * @returns 处理后的数据，图片URL已替换为对应域名的资源地址
 */
export function replaceImageDomains<T>(data: T, hostname?: string): T {
  try {
    // 获取域名配置
    const themeConfig = getThemeConfig(hostname)
    if (!themeConfig?.iconBaseUrl) {
      console.warn('No iconBaseUrl found in theme config, returning original data')
      return data
    }

    const newIconBaseUrl = themeConfig.iconBaseUrl

    // 递归处理数据
    function processValue(value: any): any {
      if (Array.isArray(value)) {
        return value.map(item => processValue(item))
      } else if (value && typeof value === 'object') {
        const processed: any = {}
        for (const [key, val] of Object.entries(value)) {
          processed[key] = processValue(val)
        }
        return processed
      } else if (typeof value === 'string') {
        // 检查是否是图片URL
        if (isImageUrl(value)) {
          return replaceImageUrl(value, newIconBaseUrl)
        }
        return value
      }
      return value
    }

    return processValue(data)
  } catch (error) {
    console.error('Error replacing image domains:', error)
    return data
  }
}

/**
 * 判断字符串是否为图片URL
 * @param url 待检查的URL字符串
 * @returns 是否为图片URL
 */
function isImageUrl(url: string): boolean {
  // 检查是否包含常见的图片域名和路径
  const imagePatterns = [
    /https?:\/\/[^\/]+\/cdn-cgi\/image/,
    /https?:\/\/[^\/]+\/icon\//,
    /https?:\/\/[^\/]+\/img\//,
    /https?:\/\/[^\/]+\/images\//,
    /https?:\/\/[^\/]+\/assets\//,
    /\.(jpg|jpeg|png|gif|webp|svg|ico)$/i
  ]
  
  return imagePatterns.some(pattern => pattern.test(url))
}

/**
 * 替换图片URL中的域名
 * @param originalUrl 原始图片URL
 * @param newDomain 新的域名
 * @returns 替换后的URL
 */
function replaceImageUrl(originalUrl: string, newDomain: string): string {
  try {
    const url = new URL(originalUrl)
    
    // 如果URL包含cdn-cgi/image路径，保持原有路径结构
    if (url.pathname.includes('/cdn-cgi/image')) {
      return `https://${newDomain}${url.pathname}${url.search}`
    }
    
    // 如果URL包含icon、img、images、assets等路径，保持原有路径结构
    if (url.pathname.includes('/icon/') || 
        url.pathname.includes('/img/') || 
        url.pathname.includes('/images/') || 
        url.pathname.includes('/assets/')) {
      return `https://${newDomain}${url.pathname}${url.search}`
    }
    
    // 其他情况，只替换域名部分
    return `https://${newDomain}${url.pathname}${url.search}`
  } catch (error) {
    console.warn('Invalid URL format, returning original:', originalUrl)
    return originalUrl
  }
}

/**
 * 批量替换多个数据文件的图片域名
 * @param dataArray 数据数组
 * @param hostname 可选的 hostname 参数
 * @returns 处理后的数据数组
 */
export function replaceImageDomainsBatch<T>(dataArray: T[], hostname?: string): T[] {
  return dataArray.map(data => replaceImageDomains(data, hostname))
}

/**
 * 获取当前域名的图片基础URL
 * @param hostname 可选的 hostname 参数
 * @returns 图片基础URL
 */
export function getImageBaseUrl(hostname?: string): string | null {
  try {
    const themeConfig = getThemeConfig(hostname)
    return themeConfig?.iconBaseUrl || null
  } catch (error) {
    console.error('Error getting image base URL:', error)
    return null
  }
} 